Aminet 1 (Walnut Creek)

home *** CD-ROM | disk | FTP | other *** search

/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / util / icontols / part02 < prev

Wrap

Internet Message Format | 1990-07-15 | 44KB

Path: xanth!cs.odu.edu!Amiga-Request From: Amiga-Request@cs.odu.edu (Amiga Sources/Binaries Moderator) Newsgroups: comp.sources.amiga Subject: v90i211: icontools - tools for managing icons under workbench, Part02/02 Message-ID: <13132@xanth.cs.odu.edu> Date: 15 Jul 90 22:37:46 GMT Sender: tadguy@cs.odu.edu Reply-To: rich@californium.cchem.berkeley.ed (Rich Mazzarisi) Lines: 846 Approved: tadguy@cs.odu.edu (Tad Guy) X-Mail-Submissions-To: Amiga@cs.odu.edu X-Post-Discussions-To: comp.sys.amiga Submitted-by: rich@californium.cchem.berkeley.ed (Rich Mazzarisi) Posting-number: Volume 90, Issue 211 Archive-name: util/icontools/part02 #!/bin/sh # This is a shell archive. Remove anything before this line, then unpack # it by saving it into a file and typing "sh file". To overwrite existing # files, type "sh file -c". You can also feed this as standard input via # unshar, or by typing "sh <file", e.g.. If this archive is complete, you # will see the following message at the end: # "End of archive 2 (of 2)." # Contents: arp/ArpBase.j.aa # Wrapped by tadguy@xanth on Sun Jul 15 18:36:27 1990 PATH=/bin:/usr/bin:/usr/ucb ; export PATH if test -f 'arp/ArpBase.j.aa' -a "${1}" != "-c" ; then echo shar: Will not clobber existing file \"'arp/ArpBase.j.aa'\" else echo shar: Extracting \"'arp/ArpBase.j.aa'\" $41051 characters$ sed "s/^X//" >'arp/ArpBase.j.aa' <<'END_OF_FILE' X\ ArpBase.j X\ AMIGA JForth Include file. X\ X\ converted 11/24/89 by R. Mazzarisi using the H2J program by Phil Burke from X\ the JForth Goodies #1 package X\ lines which were unconvertable by the program, which I attempted to X\ convert are marked "correct below? -RM" X\ X\ 11/24/89 the only parts tested are the data structures for opening the X\ library and for the functions ArpAllocFreq and FileRequest X\ Xinclude? :struct ju:c_struct Xdecimal XEXISTS? LIBRARIES_ARPBASE_H NOT .IF X1 constant LIBRARIES_ARPBASE_H X.THEN \ %? Forced .THEN to prevent nesting!!! X X( ) X( ************************************************************************) X( * *) X( * 5/3/89 ARPbase.h by MKSoft from ARPbase.i by SDB *) X( * *) X( ************************************************************************) X( * *) X( * AmigaDOS Resource Project -- Library Include File *) X( * for Lattice C 5.x or Manx C 3.6 *) X( * *) X( ************************************************************************) X( * *) X( * Copyright [c] 1987/1988/1989 by Scott Ballantyne *) X( * *) X( * The arp.library, and related code and files may be freely used *) X( * by supporters of ARP. Modules in the arp.library may not be *) X( * extracted for use in independent code, but you are welcome to *) X( * provide the arp.library with your work and call on it freely. *) X( * *) X( * You are equally welcome to add new functions, improve the ones *) X( * within, or suggest additions. *) X( * *) X( * BCPL programs are not welcome to call on the arp.library. *) X( * The welcome mat is out to all others. *) X( * *) X( ************************************************************************) X( * *) X( * N O T E ! You MUST! have IoErr[] defined as LONG to use LastTracker *) X( * If your compiler has other defines for this, you may wish *) X( * to remove the prototype for IoErr[] from this file. *) X( * *) X( ************************************************************************) X( ) X X( ) X( ************************************************************************) X( * First we need to include the Amiga Standard Include files... *) X( ************************************************************************) X( ) X XEXISTS? EXEC_TYPES_H NOT .IF Xinclude ji:EXEC/Types.j X.THEN X XEXISTS? EXEC_LISTS_H NOT .IF Xinclude ji:EXEC/Lists.j X.THEN X XEXISTS? EXEC_ALERTS_H NOT .IF Xinclude ji:EXEC/Alerts.j X.THEN X XEXISTS? EXEC_LIBRARIES_H NOT .IF Xinclude ji:EXEC/Libraries.j X.THEN X XEXISTS? EXEC_SEMAPHORES_H NOT .IF Xinclude ji:EXEC/Semaphores.j X.THEN X XEXISTS? LIBRARIES_DOS_H NOT .IF Xinclude ji:Libraries/DOS.j X.THEN X X( ) X( ************************************************************************) X( * Standard definitions for arp library information *) X( ************************************************************************) X( ) X0" arp.library" 0string ArpName ( Name of library... ) X39 constant ArpVersion ( Current version... ) X X( ) X( ************************************************************************) X( * The current ARP library node... *) X( ************************************************************************) X( ) X X:STRUCT ArpBase X STRUCT Library ab_LibNode ( Standard library node ) X APTR ab_DosRootNode ( Copy of dl_Root ) X UBYTE ab_Flags ( See bitdefs below ) X UBYTE ab_ESCChar ( Character to be used for escaping ) X LONG ab_ArpReserved1 ( ArpLib's use only!! ) X APTR ab_EnvBase ( Dummy library for MANX compatibility) X APTR ab_DosBase ( Cached DosBase ) X APTR ab_GfxBase ( Cached GfxBase ) X APTR ab_IntuiBase ( Cached IntuitionBase ) X STRUCT MinList ab_ResLists ( Resource trackers ) X APTR ab_ResidentPrgList ( Resident Programs. ) X STRUCT SignalSemaphore ab_ResPrgProtection ( protection for above ) X LONG ab_SegList ( Pointer to loaded libcode [a BPTR]. ) X ;STRUCT X X X( ) X( ************************************************************************) X( * The following is here *ONLY* for information and for *) X( * compatibility with MANX. DO NOT use in new code! *) X( ************************************************************************) X( ) XEXISTS? ARP_PRIVATE .IF X X:STRUCT EnvBase X STRUCT Library eb_LibNode ( Standard library node for linkage ) X APTR eb_EnvSpace ( Access only when Forbidden! ) X ULONG eb_EnvSize ( Total allocated mem for EnvSpace ) X APTR eb_ArpBase ( Added in V32 for Resource Tracking ) X ;STRUCT X X.THEN X X( ) X( ************************************************************************) X( * These are used in release 33.4 but not by the library code. *) X( * Instead, individual programs check for these flags. *) X( ************************************************************************) X( ) X0 constant ARPB_WILD_WORLD ( Mixed BCPL/Normal wildcards. ) X1 constant ARPB_WILD_BCPL ( Pure BCPL wildcards. ) X X1 ARPB_WILD_WORLD << constant ARPF_WILD_WORLD X1 ARPB_WILD_BCPL << constant ARPF_WILD_BCPL X X( ) X( ************************************************************************) X( * The alert object is what you use if you really must return an alert *) X( * to the user. You would normally OR this with another alert number *) X( * from the alerts.h file. Generally, should be NON deadend alerts. *) X( * *) X( * For example, if you can't open ArpLibrary: *) X( * Alert[ [AG_OpenLib|AO_ArpLib], 0L]; *) X( ************************************************************************) X( ) X$ 00008036 constant AO_ArpLib ( Alert object ) X X( ) X( ************************************************************************) X( * Alerts that arp.library may return... *) X( ************************************************************************) X( ) X$ 03600000 constant AN_ArpLib ( Alert number ) X$ 03610000 constant AN_ArpNoMem ( No more memory ) X$ 03610002 constant AN_ArpInputMem ( No memory for input buffer ) X$ 83610003 constant AN_ArpNoMakeEnv ( No memory to make EnvLib ) X X$ 83630001 constant AN_ArpNoDOS ( Can't open dos.library ) X$ 83630002 constant AN_ArpNoGfx ( Can't open graphics.library ) X$ 83630003 constant AN_ArpNoIntuit ( Can't open intuition ) X$ 83640000 constant AN_BadPackBlues ( Bad packet returned to SendPacket[] ) X$ 83600003 constant AN_Zombie ( Zombie roaming around system ) X X$ 83600002 constant AN_ArpScattered ( Scatter loading not allowed for arp ) X X X( ) X( ************************************************************************) X( * Return codes you can get from calling ARP Assign[]... *) X( ************************************************************************) X( ) X0 constant ASSIGN_OK ( Everything is cool and groovey ) X1 constant ASSIGN_NODEV ( "Physical" is not valid for assignment ) X2 constant ASSIGN_FATAL ( Something really icky happened ) X3 constant ASSIGN_CANCEL ( Tried to cancel something but it won't cancel ) X X( ) X( ************************************************************************) X( * Size of buffer you need if you are going to call ReadLine[] *) X( ************************************************************************) X( ) X256 constant MaxInputBuf X X( ) X( ************************************************************************) X( * The ARP file requester data structure... *) X( ************************************************************************) X( ) X X:STRUCT FileRequester X APTR fr_Hail ( Hailing text ) X APTR fr_File ( Filename array [FCHARS + 1] ) X APTR fr_Dir ( Directory array [DSIZE + 1] ) X APTR fr_Window ( Window requesting or NULL ) X UBYTE fr_FuncFlags ( Set bitdef's below ) X UBYTE fr_Flags2 ( New flags... ) X\ %? correct below? -RM VOID (*fr_Function)(); /* Your function, see bitdef's */ X APTR fr_Function() ( Your function, see bitdef's ) X SHORT fr_LeftEdge ( To be used later... ) X SHORT fr_TopEdge X ;STRUCT X X X( ) X( ************************************************************************) X( * The following are the defines for fr_FuncFlags. These bits tell *) X( * FileRequest[] what your fr_UserFunc is expecting, and what *) X( * FileRequest[] should call it for. *) X( * *) X( * You are called like so: *) X( * fr_Function[Mask, Object] *) X( * ULONG Mask; *) X( * CPTR *Object; *) X( * *) X( * The Mask is a copy of the flag value that caused FileRequest[] to *) X( * call your function. You can use this to determine what action you *) X( * need to perform, and exactly what Object is, so you know what to do *) X( * and what to return. *) X( ************************************************************************) X( ) X7 constant FRB_DoWildFunc ( Call me with a FIB and a name, ZERO return accepts. ) X6 constant FRB_DoMsgFunc ( You get all IDCMP messages not for FileRequest[] ) X5 constant FRB_DoColor ( Set this bit for that new and different look ) X4 constant FRB_NewIDCMP ( Force a new IDCMP [only if fr_Window != NULL] ) X3 constant FRB_NewWindFunc ( You get to modify the newwindow structure. ) X2 constant FRB_AddGadFunc ( You get to add gadgets. ) X1 constant FRB_GEventFunc ( Function to call if one of your gadgets is selected. ) X0 constant FRB_ListFunc ( Not implemented yet. ) X X1 FRB_DoWildFunc << constant FRF_DoWildFunc X1 FRB_DoMsgFunc << constant FRF_DoMsgFunc X1 FRB_DoColor << constant FRF_DoColor X1 FRB_NewIDCMP << constant FRF_NewIDCMP X1 FRB_NewWindFunc << constant FRF_NewWindFunc X1 FRB_AddGadFunc << constant FRF_AddGadFunc X1 FRB_GEventFunc << constant FRF_GEventFunc X1 FRB_ListFunc << constant FRF_ListFunc X X( ) X( ************************************************************************) X( * The FR2B_ bits are for fr_Flags2 in the file requester structure *) X( ************************************************************************) X( ) X0 constant FR2B_LongPath ( Specify the fr_Dir buffer is 256 bytes long ) X X1 FR2B_LongPath << constant FR2F_LongPath X X( ) X( ************************************************************************) X( * The sizes of the different buffers... *) X( ************************************************************************) X( ) X32 constant FCHARS ( Filename size ) X33 constant DSIZE ( Directory name size if not FR2B_LongPath ) X X254 constant LONG_DSIZE ( If FR2B_LongPath is set, use LONG_DSIZE ) X126 constant LONG_FSIZE ( For compatibility with ARPbase.i ) X X$ 7680 constant FR_FIRST_GADGET ( User gadgetID's must be less than this value ) X X( ) X( ************************************************************************) X( * Structure expected by FindFirst[]/FindNext[] *) X( * *) X( * You need to allocate this structure and initialize it as follows: *) X( * *) X( * Set ap_BreakBits to the signal bits [CDEF] that you want to take a *) X( * break on, or NULL, if you don't want to convenience the user. *) X( * *) X( * if you want to have the FULL PATH NAME of the files you found, *) X( * allocate a buffer at the END of this structure, and put the size of *) X( * it into ap_StrLen. If you don't want the full path name, make sure *) X( * you set ap_StrLen to zero. In this case, the name of the file, and *) X( * stats are available in the ap_Info, as per usual. *) X( * *) X( * Then call FindFirst[] and then afterwards, FindNext[] with this *) X( * structure. You should check the return value each time [see below] *) X( * and take the appropriate action, ultimately calling *) X( * FreeAnchorChain[] when there are no more files and you are done. *) X( * You can tell when you are done by checking for the normal AmigaDOS *) X( * return code ERROR_NO_MORE_ENTRIES. *) X( * *) X( * You will also have to check the DirEntryType variable in the ap_Info *) X( * structure to determine what exactly you have received. *) X( ************************************************************************) X( ) X X:STRUCT AnchorPath X APTR ap_Base ( Pointer to first anchor ) X APTR ap_Last ( Pointer to last anchor ) X LONG ap_BreakBits ( Bits to break on ) X LONG ap_FoundBreak ( Bits we broke on. Also returns ERROR_BREAK ) X BYTE ap_Flags ( New use for the extra word... ) X BYTE ap_Reserved ( To fill it out... ) X SHORT ap_StrLen ( This is what used to be ap_Length ) X STRUCT FileInfoBlock ap_Info X ( %?) 1 BYTES ap_Buf ( Allocate a buffer here, if desired ) X ;STRUCT X X X( ) X( ************************************************************************) X( * Bit definitions for the new ap_Flags... *) X( ************************************************************************) X( ) X0 constant APB_DoWild ( User option ALL ) X1 constant APB_ItsWild ( Set by FindFirst, used by FindNext ) X2 constant APB_DoDir ( Bit is SET if a DIR node should be entered ) X ( Application can RESET this bit to AVOID ) X ( entering a dir. ) X3 constant APB_DidDir ( Bit is set for an "expired" dir node ) X4 constant APB_NoMemErr ( Set if there was not enough memory ) X5 constant APB_DoDot ( If set, '.' [DOT] will convert to CurrentDir ) X X1 APB_DoWild << constant APF_DoWild X1 APB_ItsWild << constant APF_ItsWild X1 APB_DoDir << constant APF_DoDir X1 APB_DidDir << constant APF_DidDir X1 APB_NoMemErr << constant APF_NoMemErr X1 APB_DoDot << constant APF_DoDot X X( ) X( ************************************************************************) X( * Structure used by the pattern matching functions, no need to obtain, *) X( * diddle or allocate this yourself. *) X( * *) X( * Note: If you did, you will now break as it has changed... *) X( ************************************************************************) X( ) XEXISTS? ARP_PRIVATE .IF X X:STRUCT AChain X APTR an_Child X APTR an_Parent X APTR an_Lock X APTR an_Info X BYTE an_Flags X ( %?) 1 BYTES an_String ( Just as is .i file ) X ;STRUCT X ( ??? Don't use this! ) X.THEN X X0 constant DDB_PatternBit X1 constant DDB_ExaminedBit X2 constant DDB_Completed X3 constant DDB_AllBit X X1 DDB_PatternBit << constant DDF_PatternBit X1 DDB_ExaminedBit << constant DDF_ExaminedBit X1 DDB_Completed << constant DDF_Completed X1 DDB_AllBit << constant DDF_AllBit X X( ) X( ************************************************************************) X( * This structure takes a pointer, and returns FALSE if wildcard was *) X( * not found by FindFirst[] *) X( ************************************************************************) X( ) X\ %? #define IsWild( ptr ) ( *((LONG *)(ptr)) ): IsWild ; X X( ) X( ************************************************************************) X( * Constants used by wildcard routines *) X( * *) X( * These are the pre-parsed tokens referred to by pattern match. It *) X( * is not necessary for you to do anything about these, FindFirst[] *) X( * FindNext[] handle all these for you. *) X( ************************************************************************) X( ) X$ 80 constant P_ANY ( Token for '*' | '#?' ) X$ 81 constant P_SINGLE ( Token for '?' ) X X( ) X( ************************************************************************) X( * No need to muck with these as they may change... *) X( ************************************************************************) X( ) XEXISTS? ARP_PRIVATE .IF X$ 82 constant P_ORSTART ( Token for '[' ) X$ 83 constant P_ORNEXT ( Token for '|' ) X$ 84 constant P_OREND ( Token for ']' ) X$ 85 constant P_NOT ( Token for '~' ) X$ 87 constant P_NOTCLASS ( Token for '^' ) X$ 88 constant P_CLASS ( Token for '[]' ) X$ 89 constant P_REPBEG ( Token for '[' ) X$ 8A constant P_REPEND ( Token for ']' ) X.THEN X X( ) X( ************************************************************************) X( * Structure used by AddDANode[], AddDADevs[], FreeDAList[]. *) X( * *) X( * This structure is used to create lists of names, which normally *) X( * are devices, assigns, volumes, files, or directories. *) X( ************************************************************************) X( ) X X:STRUCT DirectoryEntry X APTR de_Next ( Next in list ) X BYTE de_Type ( DLX_mumble ) X BYTE de_Flags ( For future expansion, DO NOT USE! ) X ( %?) 1 BYTES de_Name ( The name of the thing found ) X ;STRUCT X X X( ) X( ************************************************************************) X( * Defines you use to get a list of the devices you want to look at. *) X( * For example, to get a list of all directories and volumes, do: *) X( * *) X( * AddDADevs[ mydalist, [DLF_DIRS | DLF_VOLUMES] ] *) X( * *) X( * After this, you can examine the de_type field of the elements added *) X( * to your list [if any] to discover specifics about the objects added. *) X( * *) X( * Note that if you want only devices which are also disks, you must *) X( * [DLF_DEVICES | DLF_DISKONLY]. *) X( ************************************************************************) X( ) X0 constant DLB_DEVICES ( Return devices ) X1 constant DLB_DISKONLY ( Modifier for above: Return disk devices only ) X2 constant DLB_VOLUMES ( Return volumes only ) X3 constant DLB_DIRS ( Return assigned devices only ) X X1 DLB_DEVICES << constant DLF_DEVICES X1 DLB_DISKONLY << constant DLF_DISKONLY X1 DLB_VOLUMES << constant DLF_VOLUMES X1 DLB_DIRS << constant DLF_DIRS X X( ) X( ************************************************************************) X( * Legal de_Type values, check for these after a call to AddDADevs[], *) X( * or use on your own as the ID values in AddDANode[]. *) X( ************************************************************************) X( ) X0 constant DLX_FILE ( AddDADevs[] can't determine this ) X8 constant DLX_DIR ( AddDADevs[] can't determine this ) X16 constant DLX_DEVICE ( It's a resident device ) X X24 constant DLX_VOLUME ( Device is a volume ) X32 constant DLX_UNMOUNTED ( Device is not resident ) X X40 constant DLX_ASSIGN ( Device is a logical assignment ) X X( ) X( ************************************************************************) X( * This macro is to check for an error return from the Atol[] *) X( * routine. If Errno is ERRBADINT, then there was an error... *) X( * This was done to try to remain as close to source compatible *) X( * as possible with the older [rel 1.1] ARPbase.h *) X( ************************************************************************) X( ) X1 constant ERRBADINT X\ %? #define Errno (IoErr() ? ERRBADINT : 0) X X( ) X( ************************************************************************) X( * Resource Tracking stuff... *) X( ************************************************************************) X( * *) X( * There are a few things in arp.library that are only directly *) X( * acessable from assembler. The glue routines provided by us for *) X( * all 'C' compilers use the following conventions to make these *) X( * available to C programs. The glue for other language's should use *) X( * as similar a mechanism as possible, so that no matter what language *) X( * or compiler we speak, when talk about arp, we will know what the *) X( * other guy is saying. *) X( * *) X( * Here are the cases: *) X( * *) X( * Tracker calls... *) X( * These calls return the Tracker pointer as a secondary *) X( * result in the register A1. For C, there is no clean *) X( * way to return more than one result so the tracker *) X( * pointer is returned in IoErr[]. For ease of use, *) X( * there is a define that typecasts IoErr[] to the correct *) X( * pointer type. This is called LastTracker and should *) X( * be source compatible with the earlier method of storing *) X( * the secondary result. *) X( * *) X( * GetTracker[] - *) X( * Syntax is a bit different for C than the assembly call *) X( * The C syntax is GetTracker[ID]. The binding routines *) X( * will store the ID into the tracker on return. Also, *) X( * in an effort to remain consistant, the tracker will *) X( * also be stored in LastTracker. *) X( * *) X( * In cases where you have allocated a tracker before you have obtained *) X( * a resource [usually the most efficient method], and the resource has *) X( * not been obtained, you will need to clear the tracker id. The macro *) X( * CLEAR_ID[] has been provided for that purpose. It expects a pointer *) X( * to a DefaultTracker sort of struct. *) X( ************************************************************************) X( ) X\ %? #define CLEAR_ID(t) ((SHORT *) t)[-1]=NULL: CLEAR_ID ; X X( ) X( ************************************************************************) X( * You MUST prototype IoErr[] to prevent the possible error in defining *) X( * IoErr[] and thus causing LastTracker to give you trash... *) X( * *) X( * N O T E ! You MUST! have IoErr[] defined as LONG to use LastTracker *) X( * If your compiler has other defines for this, you may wish *) X( * to remove the prototype for IoErr[]. *) X( ************************************************************************) X( ) X\ %? #define LastTracker ((struct DefaultTracker *)IoErr()) X X( ) X( ************************************************************************) X( * The rl_FirstItem list [ResList] is a list of TrackedResource [below] *) X( * It is very important that nothing in this list depend on the task *) X( * existing at resource freeing time [i.e., RemTask[0L] type stuff, *) X( * DeletePort[] and the rest]. *) X( * *) X( * The tracking functions return a struct Tracker *Tracker to you, this *) X( * is a pointer to whatever follows the tr_ID variable. *) X( * The default case is reflected below, and you get it if you call *) X( * GetTracker[] [ see DefaultTracker below]. *) X( * *) X( * NOTE: The two user variables mentioned in an earlier version don't *) X( * exist, and never did. Sorry about that [SDB]. *) X( * *) X( * However, you can still use ArpAlloc[] to allocate your own tracking *) X( * nodes and they can be any size or shape you like, as long as the *) X( * base structure is preserved. They will be freed automagically just *) X( * like the default trackers. *) X( ************************************************************************) X( ) X X:STRUCT TrackedResource X STRUCT MinNode tr_Node ( Double linked pointer ) X BYTE tr_Flags ( Don't touch ) X BYTE tr_Lock ( Don't touch, for Get/FreeAccess[] ) X SHORT tr_ID ( Item's ID ) X X( ) X( ************************************************************************) X( * The struct DefaultTracker *Tracker portion of the structure. *) X( * The stuff below this point can conceivably vary, depending *) X( * on user needs, etc. This reflects the default. *) X( ************************************************************************) X( ) X union{ X\ %? correct below? -RM CPTR tr_Resource; /* Whatever */ X APTR tr_Resource ( Whatever ) X }union{ X LONG tg_Verify ( For use during TRAK_GENERIC ) X }union \ tr_Object; /* The thing being tracked */ X union{ X\ %? correct below? -RM VOID (*tg_Function)();/* Function to call for TRAK_GENERIC */ X APTR tg_Function() ( Function to call for TRAK_GENERIC ) X }union{ X APTR tr_Window2 ( For TRAK_WINDOW ) X }union \ tr_Extra; /* Only needed sometimes */ X ;STRUCT X X X\ %? #define tg_Value tg_Verify /* Ancient compatibility only! Do NOT use in new CODE!!! */ X X( ) X( ************************************************************************) X( * You get a pointer to a struct of the following type when you call *) X( * GetTracker[]. You can change this, and use ArpAlloc[] instead of *) X( * GetTracker[] to do tracking. Of course, you have to take a wee bit *) X( * more responsibility if you do, as well as if you use TRAK_GENERIC *) X( * stuff. *) X( * *) X( * TRAK_GENERIC folks need to set up a task function to be called when *) X( * an item is freed. Some care is required to set this up properly. *) X( * *) X( * Some special cases are indicated by the unions below, for *) X( * TRAK_WINDOW, if you have more than one window opened, and don't *) X( * want the IDCMP closed particularly, you need to set a ptr to the *) X( * other window in dt_Window2. See CloseWindowSafely[] for more info. *) X( * If only one window, set this to NULL. *) X( ************************************************************************) X( ) X X:STRUCT DefaultTracker X union{ X\ %? correct below? -RM CPTR dt_Resource; /* Whatever */ X APTR dt_Resource ( Whatever ) X }union{ X LONG tg_Verify ( For use during TRAK_GENERIC ) X }union \ dt_Object; /* The object being tracked */ X union{ X\ %? correct below? -RM VOID (*tg_Function)();/* Function to call for TRAK_GENERIC */ X APTR tg_Function() ( Function to call for TRAK_GENERIC ) X }union{ X APTR dt_Window2 ( For TRAK_WINDOW ) X }union \ dt_Extra; X ;STRUCT X X X( ) X( ************************************************************************) X( * Items the tracker knows what to do about *) X( ************************************************************************) X( ) X0 constant TRAK_AAMEM ( Default [ArpAlloc] element ) X1 constant TRAK_LOCK ( File lock ) X2 constant TRAK_FILE ( Opened file ) X3 constant TRAK_WINDOW ( Window -- see docs ) X4 constant TRAK_SCREEN ( Screen ) X5 constant TRAK_LIBRARY ( Opened library ) X6 constant TRAK_DAMEM ( Pointer to DosAllocMem block ) X7 constant TRAK_MEMNODE ( AllocEntry[] node ) X8 constant TRAK_SEGLIST ( Program segment ) X9 constant TRAK_RESLIST ( ARP [nested] ResList ) X10 constant TRAK_MEM ( Memory ptr/length ) X11 constant TRAK_GENERIC ( Generic Element, your choice ) X12 constant TRAK_DALIST ( DAlist [ aka file request ] ) X13 constant TRAK_ANCHOR ( Anchor chain [pattern matching] ) X14 constant TRAK_FREQ ( FileRequest struct ) X15 constant TRAK_FONT ( GfxBase CloseFont[] ) X15 constant TRAK_MAX ( Poof, anything higher is tossed ) X X7 constant TRB_UNLINK ( Free node bit ) X6 constant TRB_RELOC ( This may be relocated [not used yet] ) X5 constant TRB_MOVED ( Item moved ) X X1 TRB_UNLINK << constant TRF_UNLINK X1 TRB_RELOC << constant TRF_RELOC X1 TRB_MOVED << constant TRF_MOVED X X( ) X( ************************************************************************) X( * Note: ResList MUST be a DosAllocMem'ed list!, this is done for *) X( * you when you call CreateTaskResList[], typically, you won't need *) X( * to access/allocate this structure. *) X( ************************************************************************) X( ) X X:STRUCT ResList X STRUCT MinNode rl_Node ( Used by arplib to link reslists ) X APTR rl_TaskID ( Owner of this list ) X STRUCT MinList rl_FirstItem ( List of Tracked Resources ) X APTR rl_Link ( SyncRun's use - hide list here ) X ;STRUCT X X X( ) X( ************************************************************************) X( * Returns from CompareLock[] *) X( ************************************************************************) X( ) X0 constant LCK_EQUAL ( The two locks refer to the same object ) X1 constant LCK_VOLUME ( Locks are on the same volume ) X2 constant LCK_DIFVOL1 ( Locks are on different volumes ) X3 constant LCK_DIFVOL2 ( Locks are on different volumes ) X X( ) X( ************************************************************************) X( * ASyncRun[] stuff... *) X( ************************************************************************) X( * Message sent back on your request by an exiting process. *) X( * You request this by putting the address of your message in *) X( * pcb_LastGasp, and initializing the ReplyPort variable of your *) X( * ZombieMsg to the port you wish the message posted to. *) X( ************************************************************************) X( ) X X:STRUCT ZombieMsg X STRUCT Message zm_ExecMessage X ULONG zm_TaskNum ( Task ID ) X LONG zm_ReturnCode ( Process's return code ) X ULONG zm_Result2 ( System return code ) X STRUCT DateStamp zm_ExitTime ( Date stamp at time of exit ) X ULONG zm_UserInfo ( For whatever you wish ) X ;STRUCT X X X( ) X( ************************************************************************) X( * Structure required by ASyncRun[] -- see docs for more info. *) X( ************************************************************************) X( ) X X:STRUCT ProcessControlBlock X ULONG pcb_StackSize ( Stacksize for new process ) X BYTE pcb_Pri ( Priority of new task ) X UBYTE pcb_Control ( Control bits, see defines below ) X APTR pcb_TrapCode ( Optional Trap Code ) X LONG pcb_Input X LONG pcb_Output ( Optional stdin, stdout ) X union{ X LONG pcb_SplatFile ( File to use for Open["*"] ) X }union{ X APTR pcb_ConName ( CON: filename ) X }union \ pcb_Console; X\ %? CPTR pcb_LoadedCode; /* If not null, will not load/unload code */ X APTR pcb_LoadedCode ( If not null, will not load/unload code ) X APTR pcb_LastGasp ( ReplyMsg[] to be filled in by exit ) X APTR pcb_WBProcess ( Valid only when PRB_NOCLI ) X ;STRUCT X X X( ) X( ************************************************************************) X( * Formerly needed to pass NULLCMD to a child. No longer needed. *) X( * It is being kept here for compatibility only... *) X( ************************************************************************) X( ) X\ %? #define NOCMD "\n" X X( ) X( ************************************************************************) X( * The following control bits determine what ASyncRun[] does on *) X( * Abnormal Exits and on background process termination. *) X( ************************************************************************) X( ) X0 constant PRB_SAVEIO ( Don't free/check file handles on exit ) X1 constant PRB_CLOSESPLAT ( Close Splat file, must request explicitly ) X2 constant PRB_NOCLI ( Don't create a CLI process ) X( PRB_INTERACTIVE 3L This is now obsolete... ) X4 constant PRB_CODE ( Dangerous yet enticing ) X5 constant PRB_STDIO ( Do the stdio thing, splat = CON:Filename ) X X1 PRB_SAVEIO << constant PRF_SAVEIO X1 PRB_CLOSESPLAT << constant PRF_CLOSESPLAT X1 PRB_NOCLI << constant PRF_NOCLI X1 PRB_CODE << constant PRF_CODE X1 PRB_STDIO << constant PRF_STDIO X X( ) X( ************************************************************************) X( * Error returns from SyncRun[] and ASyncRun[] *) X( ************************************************************************) X( ) X-1 constant PR_NOFILE ( Could not LoadSeg[] the file ) X-2 constant PR_NOMEM ( No memory for something ) X( PR_NOCLI -3L This is now obsolete ) X-4 constant PR_NOSLOT ( No room in TaskArray ) X-5 constant PR_NOINPUT ( Could not open input file ) X-6 constant PR_NOOUTPUT ( Could not get output file ) X( PR_NOLOCK -7L This is now obsolete ) X( PR_ARGERR -8L This is now obsolete ) X( PR_NOBCPL -9L This is now obsolete ) X( PR_BADLIB -10L This is now obsolete ) X-11 constant PR_NOSTDIO ( Couldn't get stdio handles ) X X( ) X( ************************************************************************) X( * Added V35 of arp.library *) X( ************************************************************************) X( ) X-12 constant PR_WANTSMESSAGE ( Child wants you to report IoErr[] to user ) X ( for SyncRun[] only... ) X-13 constant PR_NOSHELLPROC ( Can't create a shell/cli process ) X-14 constant PR_NOEXEC ( 'E' bit is clear ) X-15 constant PR_SCRIPT ( S and E are set, IoErr[] contains directory ) X X( ) X( ************************************************************************) X( * Version 35 ASyncRun[] allows you to create an independent *) X( * interactive or background Shell/CLI. You need this variant of the *) X( * pcb structure to do it, and you also have new values for nsh_Control,*) X( * see below. *) X( * *) X( * Syntax for Interactive shell is: *) X( * *) X( * rc=ASyncRun["Optional Window Name","Optional From File",&NewShell]; *) X( * *) X( * Syntax for a background shell is: *) X( * *) X( * rc=ASyncRun["Command line",0L,&NewShell]; *) X( * *) X( * Same syntax for an Execute style call, but you have to be on drugs *) X( * if you want to do that. *) X( ************************************************************************) X( ) X X:STRUCT NewShell X ULONG nsh_StackSize ( stacksize shell will use for children ) X BYTE nsh_Pri ( ignored by interactive shells ) X UBYTE nsh_Control ( bits/values: see above ) X\ %? correct below? -RM CPTR nsh_LogMsg; /* Optional login message, if null, use default */ X APTR nsh_LogMsg ( Optional login message, if null, use default ) X LONG nsh_Input ( ignored by interactive shells, but ) X LONG nsh_Output ( used by background and execute options. ) X ( %?) 5 4 * BYTES nsh_RESERVED X ;STRUCT X X X( ) X( ************************************************************************) X( * Bit Values for nsh_Control, you should use them as shown below, or *) X( * just use the actual values indicated. *) X( ************************************************************************) X( ) X0 constant PRB_CLI ( Do a CLI, not a shell ) X1 constant PRB_BACKGROUND ( Background shell ) X2 constant PRB_EXECUTE ( Do as EXECUTE... ) END_OF_FILE if test 41051 -ne `wc -c <'arp/ArpBase.j.aa'`; then echo shar: \"'arp/ArpBase.j.aa'\" unpacked with wrong size! fi # end of 'arp/ArpBase.j.aa' fi echo shar: End of archive 2 $of 2$. cp /dev/null ark2isdone MISSING="" for I in 1 2 ; do if test ! -f ark${I}isdone ; then MISSING="${MISSING} ${I}" fi done if test "${MISSING}" = "" ; then echo You have unpacked both archives. rm -f ark[1-9]isdone else echo You still need to unpack the following archives: echo " " ${MISSING} fi ## End of shell archive. exit 0 -- Mail submissions (sources or binaries) to <amiga@cs.odu.edu>. Mail comments to the moderator at <amiga-request@cs.odu.edu>. Post requests for sources, and general discussion to comp.sys.amiga.